Path 1: 76 calls (0.09)

⇇ yield datetime (1124)

60 run 151 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 2: 51 calls (0.06)

⇇ yield datetime (143)

↩ return None (51)

58 run 153 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 3: 48 calls (0.05)

⇇ yield datetime (140)

↩ return None (48)

66 run 145 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 4: 40 calls (0.05)

⇇ yield datetime (120)

↩ return None (40)

64 run 147 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 5: 36 calls (0.04)

⇇ yield datetime (108)

↩ return None (36)

78 run 133 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 6: 33 calls (0.04)

⇇ yield datetime (99)

↩ return None (33)

77 run 134 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 7: 33 calls (0.04)

⇇ yield datetime (99)

↩ return None (33)

70 run 141 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 8: 32 calls (0.04)

⇇ yield datetime (132)

↩ return None (32)

64 run 147 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 9: 25 calls (0.03)

⇇ yield datetime (75)

↩ return None (25)

67 run 144 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 10: 24 calls (0.03)

⇇ yield datetime (72)

↩ return None (24)

91 run 120 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 11: 24 calls (0.03)

⇇ yield datetime (72)

↩ return None (24)

102 run 109 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 12: 24 calls (0.03)

⇇ yield datetime (74)

↩ return None (24)

67 run 144 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 13: 24 calls (0.03)

⇇ yield datetime (72)

↩ return None (24)

109 run 102 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 14: 19 calls (0.02)

⇇ yield datetime (73)

↩ return None (19)

75 run 136 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 15: 18 calls (0.02)

⇇ yield datetime (54)

↩ return None (18)

75 run 136 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 16: 18 calls (0.02)

⇇ yield datetime (48)

↩ return None (18)

60 run 151 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 17: 18 calls (0.02)

⇇ yield datetime (54)

↩ return None (18)

72 run 139 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 18: 15 calls (0.02)

⇇ yield datetime (45)

↩ return None (15)

85 run 126 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 19: 12 calls (0.01)

⇇ yield datetime (48)

↩ return None (12)

80 run 131 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 20: 12 calls (0.01)

⇇ yield datetime (48)

↩ return None (12)

73 run 138 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 21: 12 calls (0.01)

⇇ yield datetime (36)

↩ return None (12)

89 run 122 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 22: 12 calls (0.01)

⇇ yield datetime (48)

↩ return None (12)

82 run 129 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 23: 12 calls (0.01)

⇇ yield datetime (48)

↩ return None (12)

67 run 144 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 24: 9 calls (0.01)

⇇ yield datetime (68) None (9)

⚠ exception GeneratorExit (9)

60 run 151 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 25: 9 calls (0.01)

⇇ yield datetime (27)

↩ return None (9)

79 run 132 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 26: 9 calls (0.01)

⇇ yield datetime (27)

↩ return None (9)

77 run 134 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 27: 9 calls (0.01)

⇇ yield datetime (27)

↩ return None (9)

88 run 123 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 28: 9 calls (0.01)

⇇ yield datetime (27)

↩ return None (9)

99 run 112 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 29: 9 calls (0.01)

⇇ yield datetime (27)

↩ return None (9)

106 run 105 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 30: 9 calls (0.01)

⇇ yield datetime (27)

↩ return None (9)

80 run 131 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 31: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

56 run 155 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 32: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

66 run 145 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 33: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

93 run 118 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 34: 6 calls (0.01)

⇇ yield datetime (24)

↩ return None (6)

94 run 117 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 35: 6 calls (0.01)

⇇ yield datetime (24)

↩ return None (6)

91 run 120 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 36: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

82 run 129 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 37: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

87 run 124 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 38: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

104 run 107 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 39: 6 calls (0.01)

⇇ yield datetime (24)

↩ return None (6)

105 run 106 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 40: 6 calls (0.01)

⇇ yield datetime (24)

↩ return None (6)

102 run 109 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 41: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

65 run 146 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 42: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

88 run 123 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 43: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

91 run 120 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 44: 6 calls (0.01)

⇇ yield datetime (18)

↩ return None (6)

111 run 100 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 45: 6 calls (0.01)

⇇ yield datetime (24)

↩ return None (6)

112 run 99 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 46: 6 calls (0.01)

⇇ yield datetime (24)

↩ return None (6)

109 run 102 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 47: 5 calls (0.01)

⇇ yield datetime (15)

56 run 155 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 48: 4 calls (0.0)

⇇ yield datetime (10)

↩ return None (4)

62 run 149 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 49: 4 calls (0.0)

⇇ yield FakeDatetime (12)

↩ return None (4)

73 run 138 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 50: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

76 run 135 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 51: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

74 run 137 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 52: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

75 run 136 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 53: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

75 run 136 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 54: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

63 run 148 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 55: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

92 run 119 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 56: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

82 run 129 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 57: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

85 run 126 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 58: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

85 run 126 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 59: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

88 run 123 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 60: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

85 run 126 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 61: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

103 run 108 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 62: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

93 run 118 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 63: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

95 run 116 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 64: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

88 run 123 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 65: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

77 run 134 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 66: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

95 run 116 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 67: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

87 run 124 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 68: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

90 run 121 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 69: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

110 run 101 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 70: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

100 run 111 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 71: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

92 run 119 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 72: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

94 run 117 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 73: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

77 run 134 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 74: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

77 run 134 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 75: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

68 run 143 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 76: 3 calls (0.0)

⇇ yield datetime (9)

↩ return None (3)

76 run 135 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 77: 2 calls (0.0)

⇇ yield datetime (4) None (2)

⚠ exception GeneratorExit (2)

62 run 149 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 78: 2 calls (0.0)

⇇ yield datetime (8) None (2)

⚠ exception GeneratorExit (2)

61 run 150 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 79: 2 calls (0.0)

⇇ yield datetime (4)

65 run 146 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 80: 1 calls (0.0)

↩ return None (1)

58 run 153 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 81: 1 calls (0.0)

⇇ yield datetime (1) None (1)

⚠ exception GeneratorExit (1)

54 run 157 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 82: 1 calls (0.0)

↩ return None (1)

55 run 156 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 83: 1 calls (0.0)

⚠ exception ValueError (1)

72 run 139 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 84: 1 calls (0.0)

⚠ exception ValueError (1)

78 run 133 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 85: 1 calls (0.0)

⚠ exception ValueError (1)

75 run 136 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 86: 1 calls (0.0)

⇇ yield datetime (3)

↩ return None (1)

62 run 149 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 87: 1 calls (0.0)

⇇ yield datetime (2)

↩ return None (1)

64 run 147 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)
            

Path 88: 1 calls (0.0)

↩ return None (1)

50 run 161 not run

1def _iter(self):
2        year, month, day, hour, minute, second, weekday, yearday, _ = \
3            self._dtstart.timetuple()
4
5        # Some local variables to speed things up a bit
6        freq = self._freq
7        interval = self._interval
8        wkst = self._wkst
9        until = self._until
10        bymonth = self._bymonth
11        byweekno = self._byweekno
12        byyearday = self._byyearday
13        byweekday = self._byweekday
14        byeaster = self._byeaster
15        bymonthday = self._bymonthday
16        bynmonthday = self._bynmonthday
17        bysetpos = self._bysetpos
18        byhour = self._byhour
19        byminute = self._byminute
20        bysecond = self._bysecond
21
22        ii = _iterinfo(self)
23        ii.rebuild(year, month)
24
25        getdayset = {YEARLY: ii.ydayset,
26                     MONTHLY: ii.mdayset,
27                     WEEKLY: ii.wdayset,
28                     DAILY: ii.ddayset,
29                     HOURLY: ii.ddayset,
30                     MINUTELY: ii.ddayset,
31                     SECONDLY: ii.ddayset}[freq]
32
33        if freq < HOURLY:
34            timeset = self._timeset
35        else:
36            gettimeset = {HOURLY: ii.htimeset,
37                          MINUTELY: ii.mtimeset,
38                          SECONDLY: ii.stimeset}[freq]
39            if ((freq >= HOURLY and
40                 self._byhour and hour not in self._byhour) or
41                (freq >= MINUTELY and
42                 self._byminute and minute not in self._byminute) or
43                (freq >= SECONDLY and
44                 self._bysecond and second not in self._bysecond)):
45                timeset = ()
46            else:
47                timeset = gettimeset(hour, minute, second)
48
49        total = 0
50        count = self._count
51        while True:
52            # Get dayset with the right frequency
53            dayset, start, end = getdayset(year, month, day)
54
55            # Do the "hard" work ;-)
56            filtered = False
57            for i in dayset[start:end]:
58                if ((bymonth and ii.mmask[i] not in bymonth) or
59                    (byweekno and not ii.wnomask[i]) or
60                    (byweekday and ii.wdaymask[i] not in byweekday) or
61                    (ii.nwdaymask and not ii.nwdaymask[i]) or
62                    (byeaster and not ii.eastermask[i]) or
63                    ((bymonthday or bynmonthday) and
64                     ii.mdaymask[i] not in bymonthday and
65                     ii.nmdaymask[i] not in bynmonthday) or
66                    (byyearday and
67                     ((i < ii.yearlen and i+1 not in byyearday and
68                       -ii.yearlen+i not in byyearday) or
69                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
70                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
71                    dayset[i] = None
72                    filtered = True
73
74            # Output results
75            if bysetpos and timeset:
76                poslist = []
77                for pos in bysetpos:
78                    if pos < 0:
79                        daypos, timepos = divmod(pos, len(timeset))
80                    else:
81                        daypos, timepos = divmod(pos-1, len(timeset))
82                    try:
83                        i = [x for x in dayset[start:end]
84                             if x is not None][daypos]
85                        time = timeset[timepos]
86                    except IndexError:
87                        pass
88                    else:
89                        date = datetime.date.fromordinal(ii.yearordinal+i)
90                        res = datetime.datetime.combine(date, time)
91                        if res not in poslist:
92                            poslist.append(res)
93                poslist.sort()
94                for res in poslist:
95                    if until and res > until:
96                        self._len = total
97                        return
98                    elif res >= self._dtstart:
99                        if count is not None:
100                            count -= 1
101                            if count < 0:
102                                self._len = total
103                                return
104                        total += 1
105                        yield res
106            else:
107                for i in dayset[start:end]:
108                    if i is not None:
109                        date = datetime.date.fromordinal(ii.yearordinal + i)
110                        for time in timeset:
111                            res = datetime.datetime.combine(date, time)
112                            if until and res > until:
113                                self._len = total
114                                return
115                            elif res >= self._dtstart:
116                                if count is not None:
117                                    count -= 1
118                                    if count < 0:
119                                        self._len = total
120                                        return
121
122                                total += 1
123                                yield res
124
125            # Handle frequency and interval
126            fixday = False
127            if freq == YEARLY:
128                year += interval
129                if year > datetime.MAXYEAR:
130                    self._len = total
131                    return
132                ii.rebuild(year, month)
133            elif freq == MONTHLY:
134                month += interval
135                if month > 12:
136                    div, mod = divmod(month, 12)
137                    month = mod
138                    year += div
139                    if month == 0:
140                        month = 12
141                        year -= 1
142                    if year > datetime.MAXYEAR:
143                        self._len = total
144                        return
145                ii.rebuild(year, month)
146            elif freq == WEEKLY:
147                if wkst > weekday:
148                    day += -(weekday+1+(6-wkst))+self._interval*7
149                else:
150                    day += -(weekday-wkst)+self._interval*7
151                weekday = wkst
152                fixday = True
153            elif freq == DAILY:
154                day += interval
155                fixday = True
156            elif freq == HOURLY:
157                if filtered:
158                    # Jump to one iteration before next day
159                    hour += ((23-hour)//interval)*interval
160
161                if byhour:
162                    ndays, hour = self.__mod_distance(value=hour,
163                                                      byxxx=self._byhour,
164                                                      base=24)
165                else:
166                    ndays, hour = divmod(hour+interval, 24)
167
168                if ndays:
169                    day += ndays
170                    fixday = True
171
172                timeset = gettimeset(hour, minute, second)
173            elif freq == MINUTELY:
174                if filtered:
175                    # Jump to one iteration before next day
176                    minute += ((1439-(hour*60+minute))//interval)*interval
177
178                valid = False
179                rep_rate = (24*60)
180                for j in range(rep_rate // gcd(interval, rep_rate)):
181                    if byminute:
182                        nhours, minute = \
183                            self.__mod_distance(value=minute,
184                                                byxxx=self._byminute,
185                                                base=60)
186                    else:
187                        nhours, minute = divmod(minute+interval, 60)
188
189                    div, hour = divmod(hour+nhours, 24)
190                    if div:
191                        day += div
192                        fixday = True
193                        filtered = False
194
195                    if not byhour or hour in byhour:
196                        valid = True
197                        break
198
199                if not valid:
200                    raise ValueError('Invalid combination of interval and ' +
201                                     'byhour resulting in empty rule.')
202
203                timeset = gettimeset(hour, minute, second)
204            elif freq == SECONDLY:
205                if filtered:
206                    # Jump to one iteration before next day
207                    second += (((86399 - (hour * 3600 + minute * 60 + second))
208                                // interval) * interval)
209
210                rep_rate = (24 * 3600)
211                valid = False
212                for j in range(0, rep_rate // gcd(interval, rep_rate)):
213                    if bysecond:
214                        nminutes, second = \
215                            self.__mod_distance(value=second,
216                                                byxxx=self._bysecond,
217                                                base=60)
218                    else:
219                        nminutes, second = divmod(second+interval, 60)
220
221                    div, minute = divmod(minute+nminutes, 60)
222                    if div:
223                        hour += div
224                        div, hour = divmod(hour, 24)
225                        if div:
226                            day += div
227                            fixday = True
228
229                    if ((not byhour or hour in byhour) and
230                            (not byminute or minute in byminute) and
231                            (not bysecond or second in bysecond)):
232                        valid = True
233                        break
234
235                if not valid:
236                    raise ValueError('Invalid combination of interval, ' +
237                                     'byhour and byminute resulting in empty' +
238                                     ' rule.')
239
240                timeset = gettimeset(hour, minute, second)
241
242            if fixday and day > 28:
243                daysinmonth = calendar.monthrange(year, month)[1]
244                if day > daysinmonth:
245                    while day > daysinmonth:
246                        day -= daysinmonth
247                        month += 1
248                        if month == 13:
249                            month = 1
250                            year += 1
251                            if year > datetime.MAXYEAR:
252                                self._len = total
253                                return
254                        daysinmonth = calendar.monthrange(year, month)[1]
255                    ii.rebuild(year, month)